<?php
/**
 * @package   auto_occasion
 * @subpackage 
 * @author    CMS
 * @copyright  2011
 * @license    All rights reserved
 */

class essaisSrv {

    /**
     * Fonction permettant d'avoir la liste des profils
     * @return object
     */
    public static function getById ($_iId) {
       $oFac = jDao::get("commun~ao_essais");
     
       return $oFac->get($_iId);
    }

    /**
     * Fonction permettant d'avoir la liste des profils
     * @return object
     */
    public static function getAll () {
       $oFac = jDao::get("commun~ao_essais");

       return $oFac->findAll()->fetchAll();
    }

    /**
     * Fonction permettant d'avoir la liste des profils
     * @return object
     */
    public static function deleteById ($_iId) {
       $oFac = jDao::get("commun~ao_essais");
     
       return $oFac->delete($_iId);
    }

    /**
     * Enregistrement dans la base insert comme update
     * 
     * @param array $_toParams tableau issue du formulaire
     * @return object
     */
    public static function store ($_toParams) {

        $oFac = jDao::get('commun~ao_essais') ;
        $oRecord = jDao::createRecord('commun~ao_essais') ;
        foreach ($oRecord as $zKey => $item) {
            if (array_key_exists($zKey, $_toParams)) {
                $oRecord->$zKey = $_toParams[$zKey] ;
            }
        }

        if ($oRecord->ess_id) {
            $bReturn = $oFac->update($oRecord) ;
        } else {
            $bReturn = $oFac->insert($oRecord) ;
        }
        
        return ($bReturn) ? $oRecord : $bReturn ;
    }
    
    /**
     * Renvoie tous les fiches d'un Type (modele/gamme/dossiers)
     * @param int $_iTypeId
     * @return array 
     */
    public static function getAllFichesByTypeId ($_iTypeId,$limit=0) {
        
        $oFac = jDao::get('commun~ao_essais') ;
        $oCond = jDao::createConditions() ;
        $oCond->addCondition('ess_iTypeId', '=', $_iTypeId) ;
        
        if ($limit == 0){
            $oCond->addItemOrder('ess_iOrder') ;

            return $oFac->findBy($oCond) ;
        } else {
            $oCond->addCondition('ess_zSousTitre', '<>', '') ;
            $oCond->addItemOrder('ess_id','desc') ;

            return $oFac->findBy($oCond,0,$limit) ;
        }
    }
    /**
     * Renvoie tous les fiches d'un Type (modele/gamme/dossiers)
     * @param int $_iTypeId 
     * @return array 
     */
    public static function getAllFiches ($_iTypeId = 0, $limit = 0, $_ess_id = 0, $marqueId = 0, $joinModele = false) {
        $inner = ($joinModele) ? " INNER " : " LEFT " ;
        $sql  = " SELECT * FROM ao_essais ";
        $sql .= " $inner JOIN ao_marque ON marque_id=ess_iMarqueId";
        $sql .= " $inner JOIN ao_modele ON modele_id=ess_iModelId";
        $sql .= " WHERE 1";
        if ($_ess_id) 
            $sql .= " AND ess_id =" . $_ess_id;
        if ($_iTypeId) 
            $sql .= " AND ess_iTypeId =" . $_iTypeId;

        if ($marqueId) 
            $sql .= " AND ao_essais.ess_iMarqueId = " . $marqueId;

        $sql .= " ORDER BY ess_iOrder , marque_libelle  ";
        if ($limit) 
             $sql .= " LIMIT $limit";
        $jdb     = jDb::getDbWidget();
        $tResult =  $jdb->fetchAll($sql);

        return $tResult;
    }
    
    /**
     * Renvoie tous les fiches d'une Categorie
     * @param array $_toParams
     * @return array 
     */
    public static function reOrder ($_toParams) {
        
        $oFac = jDao::get('commun~ao_essais') ;
        
        $tiFicheIds = array_key_exists('tiFicheIds', $_toParams) ? $_toParams['tiFicheIds'] : array() ;
        
        foreach ($tiFicheIds as $iKey => $iFicheId) {
            $oRec = $oFac->get($iFicheId) ;
            $oRec->ess_iOrder = $iKey ;
            $oFac->update($oRec) ;
        }
        
    }
    
    /**
     * Renvoie tous les Categories de vehicule
     * @return array 
     */
    public static function getAllCatVoiture () {
        
        $oFac = jDao::get('commun~ao_categorie_voitures') ;
        
        return $oFac->findAll() ;
    }

    /**
     * Fonction permettant de récupérer les essais sur la home, en fonction de lorder définit en BO
    */
    public static function  getRecentEssai($limit = 3) {
            
             $sql = " SELECT ess_id, ess_zSousTitre, ess_zChapeau, ess_zImage, rappel_typeId, rappel_texte, ess_iMarqueId, ess_iModelId  ";
             $sql .= " FROM ao_essais";
             $sql .= " LEFT JOIN ao_essais_rappel  ON ao_essais.ess_id = ao_essais_rappel.rappel_essai_id";
             $sql .= " GROUP BY ess_id";

//             $sql .= " ORDER BY ess_dateModif desc, ess_dateCrea desc";
             $sql .= " ORDER BY ess_iOrder ASC";
             $sql .= " LIMIT $limit";
             
             $cnx = jDb::getConnection();
             $rs     = $cnx->query($sql);

             return $rs->fetchAll();
 
    }
    /**
     * Fonction permettant de récupérer les essais sur la home, en fonction de lorder définit en BO
    */
    public static function  getRecentEssaiHome($limit = 3) {
            
             $sql = " SELECT ess_id, ess_zSousTitre, ess_zChapeau, ess_zImage, marque_libelle, modele_libelle";
             $sql .= " FROM ao_essais";
             $sql .= " LEFT JOIN ao_marque ON marque_id = ess_iMarqueId";
             $sql .= " LEFT JOIN ao_modele ON modele_id = ess_iModelId";

//             $sql .= " ORDER BY ess_dateModif desc, ess_dateCrea desc";
             $sql .= " WHERE ess_iTypeId = 1 AND ess_statut = 1 ";
             $sql .= " ORDER BY ess_iOrder ASC";
             $sql .= " LIMIT $limit";
             
             $cnx = jDb::getConnection();
             $rs     = $cnx->query($sql);

             return $rs->fetchAll();
 
    }
    
    /**
     * Fonction permettant de récupérer les essais par marque et modèle
     * @param  int $_iMarque	: Identifiant de la marque
     * @param  int $_iModele	: Identifiant du modèle
     * @return int $iEssaiId	: Identifiant de l'essai
    */
    public static function  getIdEssaiByMarqueModele ( $_iMarque , $_iModele ) {
		
		$zQuery = "
					 SELECT 
							ess_id
					 FROM	ao_essais

			      " ;
		//preparation de la condition
		$tzConditions = array() ;
		$zCondition	  = "" ;
		if ( $_iMarque != 0 ) 
		{
			$zCondition = " ess_iMarqueId = " . $_iMarque ;
			array_push($tzConditions ,$zCondition) ;
		}
		
		$zCondition = " ess_iModelId = " . $_iModele ;
		array_push($tzConditions ,$zCondition) ;
		
		$zCondition = " WHERE ".implode(" AND ",$tzConditions) ;
		$zQuery.= $zCondition ." LIMIT 1 ";
        $oConnexion = jDb::getConnection() ;
		//execution de la requete
        $oRs		= $oConnexion->query($zQuery) ;
        $oRes		= $oRs->fetchAll();
        $iEssaiId	= 0 ;
        foreach ($oRes as $oVal) {
            $iEssaiId = $oVal->ess_id ;
        }

        return $iEssaiId ;

    }

    /**
     * Fonction permettant de récupérer les essais par critere
    */
    public static function  getEssaiByCritere($critere) {
            jClasses::inc('commun~toolsFile');
             $sql  = " SELECT ess_id, ess_zSousTitre, ess_zChapeau AS chap, CONCAT(SUBSTRING(ess_zChapeau, 1, 100), ' ...') AS ess_zChapeau, marque_libelle, modele_libelle , ess_zVersion";
             $sql .= " FROM ao_essais";

             $sql .= " LEFT JOIN ao_marque ON marque_id = ess_iMarqueId";
             $sql .= " LEFT JOIN ao_modele ON modele_id = ess_iModelId";
             $sql .= " WHERE 1";

             if (isset($critere->marqueId)) {
                $sql .= " AND ess_iMarqueId = " . $critere->marqueId;
             }
             if (isset($critere->modeleId)) {
                $sql .= " AND ess_iModelId = " . $critere->modeleId;
             }
             if (isset($critere->essId) && $critere->essId) {
                $sql .= " AND ess_id = " . $critere->essId;
             }
             $sql .= " ORDER BY ess_dateModif desc, ess_dateCrea desc";

            $cnx = jDb::getConnection();
            $rs = $cnx->query($sql);
            $result = array();

            while($row = $rs->fetch()){
                if (strpos($row->chap, '.txt')) {
                    $filename = JELIX_APP_WWW_PATH . PATH_ESSAI_CHAPEAU . $row->chap;
                    $row->ess_zChapeau = toolsFile::getFile($filename);
                }
                $result[] = $row;
            }

            return $result;
 
    }
    

    /**
    * Fonction permettant de récupérer les essais par critere
    */
    public static function  getRappel($essaiId) {

             $sql = "  SELECT  rappel_typeId ";
             $sql .= " FROM ao_essais_rappel";
             $sql .= " WHERE rappel_essai_id=" .$essaiId;
             $cnx = jDb::getConnection();
             $rs = $cnx->query($sql);
             $result = array();
             while($row = $rs->fetch()){
                $result[] = $row->rappel_typeId;
             }

             return $result;
 
    }

   /**
     * Fonction permettant de récupérer les concurrences par critere
    */
    public static function  getConcurrenceByCritere($critere) {
            
             $sql  = " SELECT concur_essai_id";
             $sql .= " FROM ao_essais_concurrence ";
             $sql .= " WHERE 1";

             if (isset($critere->marqueId)) {
                $sql .= " AND concur_marque_id = " . $critere->marqueId;
             }
             if (isset($critere->modeleId)) {
                $sql .= " AND concur_modele_id = " . $critere->modeleId;
             }
            $cnx = jDb::getConnection();
            $rs = $cnx->query($sql);
            $result = array();
            while($row = $rs->fetch()){
                $result[] = $row->concur_essai_id;
            }

            return $result;
 
    }

       /**
     * Fonction permettant de récupérer les détails d'un essai ayant 
    */
    public static function  getEssais($critere,$essaiId) {
            $IN = "";
            $k = 0;
            foreach ($critere as $item)
            {
                if ($item !=$essaiId){
                    $sep = (!$k)? "" : ",";
                    $IN .= $sep . "'".$item."'";
                    $k++;
               }
            }

            $sql =  " SELECT ao_essais.* , rappel_typeId, rappel_texte  FROM ao_essais";
            $sql .= " LEFT JOIN ao_essais_rappel  ON ao_essais.ess_id = ao_essais_rappel.rappel_essai_id";
            if ($IN) {
                $sql .=" WHERE ess_id IN ($IN)";
            }
            else{ 
                $sql .=" WHERE ess_id = $essaiId";
            }
            $sql .= " GROUP BY ess_id";
            $cnx = jDb::getConnection();
            $rs     = $cnx->query($sql);

            return $rs->fetchAll();
 
    }


	/**
     * Fonction permettant de récupérer les voitures même marque et même modèle
    */
    public static function  getAnnonceMemeMarqueModele($idMarque, $idModele) {
            
        $sql = " SELECT vo.Occas_Prix , PH.photo_name, marque_logo, IdOccasion  ";
        $sql .= " from ao_voiture_occasion vo";
        $sql .= " LEFT JOIN ao_marque ma ON ma.marque_id = vo.Occas_Marque";
        $sql .= " LEFT JOIN ao_photo_annonce P ON P.annonce_id = vo.IdOccasion";
        $sql .= " LEFT JOIN ao_photo PH ON PH.photo_id = P.photo_id";
        $sql .= " WHERE Occas_Marque = " . $idMarque;
        $sql .= " AND Occas_Modele = " . $idModele;
        $sql .= " ORDER BY PH.photo_name desc, marque_logo desc";
        $sql .= " LIMIT 14";

        $cnx = jDb::getConnection();
        $rs = $cnx->query($sql);
        $result = array();

        while($row = $rs->fetch()){
            $filename = JELIX_APP_WWW_PATH . PHOTO_ANNONCE_PATH . $row->photo_name;
            if (!$row->photo_name) {
                jClasses::inc('commun~toolsFile');
                $filenameImg = JELIX_APP_WWW_PATH . PATH_ANNONCE_IMG . $row->IdOccasion ;
                $images = toolsFile::getFile($filenameImg, "img", $row->IdOccasion);
                //var_dump($images);die();
                $row->photo_name = (is_array($images) && isset($images[0]->photo_name)) ? $images[0]->photo_name : "";
            } else {
                $row->photo_name = PHOTO_ANNONCE_PATH . $row->photo_name ;
            }

            $result[] = $row;
        }

        return $result;
 
    }
    
    /*
     * Fonction retournant les marques dans les essais
     */
    public static function getAllMarqueInEssai(){
        $sql  = " SELECT ae.ess_iMarqueId,am.marque_libelle from ao_essais ae";
        $sql .= " LEFT JOIN ao_marque am ON am.marque_id = ae.ess_iMarqueId";
        $sql .= " GROUP BY  ae.ess_iMarqueId ";
        $sql .= "ORDER BY am.marque_libelle asc";
        $cnx = jDb::getConnection();
        $rs     = $cnx->query($sql);

        return $rs->fetchAll();
    }
    
    /*Fonction retournant toutes les modèles
     * de la marque donnée 
     * dans essais
     */
    public static function getAllModelsByMarqueInEssai($idMarque, $idModele = 0){
        $sql  = " SELECT ae.ess_id,ae.ess_iModelId,ama.marque_libelle,amo.modele_libelle,ae.ess_zVersion from ao_essais ae";
        $sql .= " LEFT JOIN ao_marque ama ON ama.marque_id = ae.ess_iMarqueId";
        $sql .= " LEFT JOIN ao_modele amo ON amo.modele_id = ae.ess_iModelId";
        $sql .= " WHERE ess_iMarqueId = " . $idMarque;
        if ($idModele)
            $sql .= " AND ess_iModelId = " . $idModele;

        $sql .= " ORDER BY amo.modele_libelle";
        $cnx = jDb::getConnection();
        $rs     = $cnx->query($sql);

        return $rs->fetchAll();
        
    }

        /**
     * Création du répertoire
     * @param $marqueId
     * @param $modeleId
     */
     public static function getDirectory($marqueId, $modeleId='',$type,$version='') {

        jClasses::inc('commun~common') ;
        
        //creation niveau 1 -> type
        $path = JELIX_APP_WWW_PATH . PATH_ESSAI ;
        $marque = common::chargeParId($marqueId, "ao_marque");
        
        // niveau 1: type
        $path = self::getPath($path,$type. '/');
        //niveau 2: marque
        $path = self::getPath($path,trim($marque->marque_libelle). '/');
        // niveau 3: modele-version si modele seulement
        if($type == 'Modeles'){
            $modele = common::chargeParId($modeleId, "ao_modele");
            $path = self::getPath($path,trim($modele->modele_libelle).'-'.$version. '/');
        }
     }

    /**
     * Création du répertoire
     * @param $marqueId
     * @param $modeleId
     * @param $image  dema frme /!ed/sdfsd/sdfsd/sqdf/df.jpg
     */
     public static function createDirectory($marqueId, $modeleId, $image,$type,$version) {

        jClasses::inc('commun~common') ;

        $marque						= common::chargeParId($marqueId,  "ao_marque");
        $modele						= common::chargeParId($modeleId,  "ao_modele");

        //$name = trim($marque->marque_libelle).trim($modele->modele_libelle).'_'.$marqueId.'_'.$modeleId;
        

        //creation niveau 1 -> type
        $path						= JELIX_APP_WWW_PATH . PATH_ESSAI ;
        
        // niveau 1: type
        $path						= self::getPath($path,$type. '/');
        //niveau 2: marque
		$marque->marque_libelle		= strtr($marque->marque_libelle,' ','_') ;
        $path						= self::getPath($path,trim($marque->marque_libelle). '/');

		
        // niveau 3: modele-version si modele seulement
        if($type == 'Modeles'){
			$modele->modele_libelle	= strtr($modele->modele_libelle,' ','_') ;
            $path					= self::getPath($path,trim($modele->modele_libelle).'-'.$version. '/');
        }   
        // copie de l'image
        $tempFile   = JELIX_APP_WWW_PATH . $image;
        $targetPath = $path .'/'. basename($image);
        try {
            copy($tempFile, $targetPath);
        } catch(exception $e) {
            die($e->getMessage());
        }

    }
    
    /*
     * Fonction creation dir
     * 
     */
    public static function getPath($path_begin,$toadd){
        $path = $path_begin  . $toadd;
        if( !is_dir($path)){mkdir ($path, 0777);}
        return $path;
    }
    
    /* 
     * Fonction pour inserer pour un essai
     * versions - caracteristique
     */
    public static function  insertVersionCarateristiques($iEssaiId,$idCarb,$texte){
        $cnx = jDb::getConnection();
        
        //requetes pour recuperer les positions
        $QueryVersion = "   SELECT count(TVersion_id) as numV FROM ao_technique_version
                            WHERE TVersion_essai_id = '".$iEssaiId."'
                            AND TVersion_carburation_id = '".$idCarb."'";
        $QueryTitre   = "   SELECT count(TTitre_id) as numT FROM ao_technique_titre
                            WHERE TTitre_essais_id = '".$iEssaiId."'
                            AND TTitre_carburation_id = '".$idCarb."'";
    
        
        $tabTexte   = explode(PHP_EOL,$texte);
        
        //separation du caractéristique "couple" avec les autres
       // $tab_texte_couple = array();
        $tab_texte_version = array_slice($tabTexte, 0, 1);
        if(count($tabTexte) > 1){     
            $tab_texte_classic = array_slice($tabTexte, 1);
            /*
            $tab_texte_classic = array_slice($tabTexte, 1, 4);
            $tab_texte_couple  = array_slice($tabTexte, 5, 2);
            if(count($tabTexte > 7))
            $tab_texte_classic = array_merge($tab_texte_classic ,array_slice($tabTexte, 7));
            */
        } 
        /*
         * 
        else {
            $tab_texte_classic = array_slice($tabTexte, 1);
        }
         * 
         */
        
        //suppression des versions qui existent deja
        $versionInfos    = self::getEssaiVersions($iEssaiId);
        if(count($versionInfos->listeValeur) > 0){
            $sql_del_valeur = "DELETE FROM ao_technique_valeur  WHERE TValeur_id IN (";
            foreach ($versionInfos->listeValeur as $key => $value) {
                $sql_del_valeur .= ($key == 0) ? '':',';
                $sql_del_valeur .= $value->TValeur_id;
            }
            $sql_del_valeur .= ")";
            $cnx->exec($sql_del_valeur);
        }
        $sql_del_version = "DELETE FROM ao_technique_version WHERE TVersion_essai_id = ". $iEssaiId;
        $sql_del_titre   = "DELETE FROM ao_technique_titre   WHERE TTitre_essais_id  = ". $iEssaiId;
        
        $cnx->exec($sql_del_version);
        $cnx->exec($sql_del_titre);
        // fin suppression
        
        //insertion des versions et recuperation des ids
        $tabVersion = explode(';',$tab_texte_version[0]);
        $nbVersion = count($tabVersion) - 1;
        $version    = '';
        $posVersion = $cnx->query($QueryVersion)->fetchAll();
        $posVersion = $posVersion[0]->numV + 1;
        foreach($tabVersion as $item){
            if($item != ''){
                $version   .= ($version == '') ? '':',';
                $version   .= "('".addslashes($item)."',".$idCarb.",".$posVersion.",".$iEssaiId.")";
                $posVersion++;
            }
        }
        
        $sql_insert_version  = " INSERT INTO ao_technique_version (TVersion_lib,TVersion_carburation_id,TVersion_position,TVersion_essai_id)";
        $sql_insert_version .= " VALUES" . $version;
        $cnx->exec($sql_insert_version);
        
        $sql_getVersionIds = "SELECT TVersion_id from ao_technique_version order by TVersion_id desc limit ".$nbVersion;
        $versionListe     = $cnx->query($sql_getVersionIds)->fetchAll();
        $vListe = array();
        foreach ($versionListe as $key => $value) {
            $vListe[] = $value->TVersion_id;
        }
        sort($vListe);
        $nb_vers = count($vListe);
        
        //recup position titre (0 si versions supprimées)
        $posTitre   = $cnx->query($QueryTitre)->fetchAll();
        $posTitre   = $posTitre[0]->numT + 1;
        
        /*
         * Etape 1 :
         * insertion caracteristique couple d'il y en a
         */
        /*
        if(count($tab_texte_couple) > 0){
            $posCouple = $posTitre + 4;
            //insertion titre (couple)
            $sql_insert_couple_titre    = " INSERT INTO ao_technique_titre (TTitre_lib,TTitre_position,TTitre_carburation_id,TTitre_essais_id)";
            $sql_insert_couple_titre   .= " VALUES('couple :',".$posCouple.",$idCarb,$iEssaiId)";
            $cnx->exec($sql_insert_couple_titre);
            $sql_getCoupleTitreId       = " SELECT TTitre_id FROM ao_technique_titre order by TTitre_id desc limit 1";
            $titreCoupleRes             = $cnx->query($sql_getCoupleTitreId)->fetchAll();
            $titreCoupleId              = $titreCoupleRes[0]->TTitre_id;
            
            //insertion des valeurs (couple)
            $couple1 = explode(';',$tab_texte_couple[0]);
            $couple2 = explode(';',$tab_texte_couple[1]);
            if(stripos($couple1[0],'mkg') !== false){
                $couple_mkg = $couple1;$couple_trmn = $couple2;
            } else {
                $couple_mkg = $couple2;$couple_trmn = $couple1;
            }
            $couple_val = "";
            $nb_couple  = count($couple_mkg);
            for($j = 1;$j < $nb_couple ;$j++){
                $couple_val .= ($couple_val == '') ? '':',';
                $couple_val .= "('".addslashes($couple_mkg[$j]." mkg <br> à ".$couple_trmn[$j]." tr/mn")."',".$vListe[$j -1].",".$titreCoupleId.")";
            }
            
            $sql_insert_couple_valeur  = "INSERT INTO ao_technique_valeur (TValeur_valeur,TValeur_version_id,TValeur_titre_id)";
            $sql_insert_couple_valeur .= "VALUES " . $couple_val;
            $cnx->exec($sql_insert_couple_valeur);
            $sql_getValeurIds          = " SELECT TValeur_id FROM ao_technique_valeur order by TValeur_id desc limit " . $nb_vers;
            $valeurListe               = $cnx->query($sql_getValeurIds)->fetchAll();
            $valCoupleListe            = array();
            foreach ($valeurListe as $key => $value) {
                $valCoupleListe[] = $value->TValeur_id;
            }
            sort($valCoupleListe);
            
        }
        */
        
        /*
         * fin 1ere etape et debut deuxième etape :
         * insertion des autres caractéristiques
         */
        
        
        //insertion titre et recuperation des ids
        $nb_lignes  = count($tab_texte_classic);
        $titre = array();
        $val   = array();
        for($i=0 ; $i<$nb_lignes ; $i++){
            $car = explode(';',$tab_texte_classic[$i]);
            $titre[] = $car[0];
            if(count($car) == 2){
                $tmp    = array();
                for($j=0;$j<$nb_vers;$j++) array_push ($tmp, $car[1]);
                $val[] = $tmp;
            }else {
                $val[]   = explode(';',implode(';',array_slice ($car, 1)));
            }
            
        }
        
        $titres  = '';
        foreach($titre as $item){
            $titres   .= ($titres == '') ? '':',';
            $titres   .= "('".addslashes($item)."',".$posTitre.",".$idCarb.",".$iEssaiId.")";
            $posTitre++;
           // $posTitre  = ($posTitre == ($posTitreDep +4)) ? ($posTitre + 1) : $posTitre;
        }
        $sql_insert_titre  = " INSERT INTO ao_technique_titre (TTitre_lib,TTitre_position,TTitre_carburation_id,TTitre_essais_id)";
        $sql_insert_titre .= " VALUES" . $titres;
        $cnx->exec($sql_insert_titre);
        $sql_getTitreIds = " SELECT TTitre_id FROM ao_technique_titre order by TTitre_id desc limit " . $nb_lignes;
        $titreListe      = $cnx->query($sql_getTitreIds)->fetchAll();
        $tListe = array();
        foreach ($titreListe as $key => $value) {
            $tListe[] = $value->TTitre_id;
        }
        sort($tListe);
        
        //insertion valeur des caracteristique par version
        $valeurs = '';
        foreach ($tListe as $key => $itemTitre) {
            foreach ($val[$key] as $key2 => $itemVal) {
                $valeurs   .= ($valeurs == '') ? '':',';
                $valeurs   .= "('".addslashes($itemVal)."',".$vListe[$key2].",".$itemTitre.')';
            }
        }
        $sql_insert_valeur = "INSERT INTO ao_technique_valeur (TValeur_valeur,TValeur_version_id,TValeur_titre_id)";
        $sql_insert_valeur .= "VALUES " . $valeurs;
        $cnx->exec($sql_insert_valeur);
        $sql_getValeurIds = " SELECT TValeur_id FROM ao_technique_valeur order by TValeur_id desc limit " . $nb_lignes * count($vListe);
        $valeurListe      = $cnx->query($sql_getValeurIds)->fetchAll();
        $valListe = array();
        foreach ($valeurListe as $key => $value) {
            $valListe[] = $value->TValeur_id;
        }
        sort($valListe);
        
        /*
         * fin etape 2 et ajout des ids de l'etape 1
         */
        /*
        if(count($tab_texte_couple) > 0){
            array_push($tListe,$titreCoupleId);
            $valListe = array_merge($valListe,$valCoupleListe);
        }
         * 
         */
        
        $tech = new stdClass();
        $tech->versionIds = $vListe;
        $tech->titreIds   = $tListe;
        $tech->valIds     = $valListe;
        
        return $tech; 
    }
    /*
     * fonction pour recuperer les versions et Kstiques 
     * après ajout des versions et Kstiques
     */
    public static function getVersionInfos($tech){
        $cnx = jDb::getConnection();
        
        $versionInfos = new stdClass();
        $sql_getVersion = "SELECT TVersion_id,TVersion_lib FROM ao_technique_version WHERE TVersion_id IN (".implode(',', $tech->versionIds).")";
        $versionInfos->listeVersion   = $cnx->query($sql_getVersion)->fetchAll();
        
        $sql_getTitre   = "SELECT TTitre_id,TTitre_lib FROM ao_technique_titre WHERE TTitre_id IN (".implode(',', $tech->titreIds).")";
        $versionInfos->listeTitre     = $cnx->query($sql_getTitre)->fetchAll();
        
        $sql_getValeur = "SELECT TValeur_valeur,TValeur_version_id,TValeur_titre_id FROM ao_technique_valeur WHERE TValeur_id IN (".implode(',', $tech->valIds).")";
        $versionInfos->listeValeur    = $cnx->query($sql_getValeur)->fetchAll();
        
        return $versionInfos;
    }
    
    /*
     * Fonction pour recuperer les versions et Kstiques 
     * d'un essai
     */
    public static function getEssaiVersions($idEssais){
        jClasses::inc('commun~common');
        $cnx = jDb::getConnection();
        
        $versionInfos = new stdClass();
        $sql_getVersion = "SELECT TVersion_id,TVersion_carburation_id,TVersion_lib FROM ao_technique_version WHERE TVersion_essai_id = ".$idEssais;
        $versionInfos->listeVersion   = $cnx->query($sql_getVersion)->fetchAll();
        $versListe = array();
        foreach ($versionInfos->listeVersion as $key => $value) {
            $versListe[] = $value->TVersion_id;
            $idCarburation = $value->TVersion_carburation_id;
        }
        
        $sql_getTitre   = "SELECT TTitre_id,TTitre_lib FROM ao_technique_titre WHERE TTitre_essais_id = ".$idEssais;
        $versionInfos->listeTitre     = $cnx->query($sql_getTitre)->fetchAll();
        $titreListe = array();
        foreach ($versionInfos->listeTitre as $key => $value) {
            $titreListe[] = $value->TTitre_id;
        }
        if((count($versListe) > 0) && (count($titreListe) > 0)){
            $sql_getValeur = " SELECT TValeur_id,TValeur_valeur,TValeur_version_id,TValeur_titre_id FROM ao_technique_valeur";
            $sql_getValeur.= " WHERE TValeur_version_id IN (".implode(',', $versListe).") ";
            $sql_getValeur.= " AND   TValeur_titre_id   IN (".implode(',', $titreListe).")";
            $versionInfos->listeValeur    = $cnx->query($sql_getValeur)->fetchAll();
            $versionInfos->carburation    = $idCarburation;
        } else {
            $versionInfos->listeValeur    = array();
        }
        
        
        return $versionInfos;
    }
    

    /**
     * récupérer les ids doublons des titres
     *
     * @param array $titre
     * @return array ids
     */
     public static function listeDoublonTitre ($titre) {
         $ret = $title = array();
         if (sizeof($titre)) {
            foreach ($titre as $item) {
                // regrouper les lib des title
                if (!in_array($item->TTitre_lib, $title)) {
                    $title[] = $item->TTitre_lib;
                }
            }
            // pour chaque lib de title, combiner les ids ayant mm lib 
            if (sizeof($title)) {
                foreach ($title as $lib) {
                    $j    = 0; // initialiser à zero pour stocker l'id ppal
                    $temp = array(); // array contenant les ids doublons
                    $obj  = new stdClass();
                    foreach ($titre as $item) {
                        if ($lib == $item->TTitre_lib) {
                            if (!$j) { 
                                $obj->ppal = $item->TTitre_id;
                                $j++;
                            } else {
                                $temp[] = $item->TTitre_id;
                            }

                        }
                    }
                    $obj->doubon = $temp;
                    $ret[] = $obj;
                }
            }
         }

         return $ret;
     }

    /**
     * modifie l'id ds la liste des valeus
     *
     * @param array $valeur
     * @return array 
     */
     public static function modifyValueTitle ($valeur, $tomodify) {
        foreach ($tomodify as $item) {
            if (sizeof($item->doubon)) {
                foreach ($item->doubon as $doublon) {
                    foreach ($valeur as $itemValeur) {
                        if ($itemValeur->TValeur_titre_id == $doublon) {
                            $itemValeur->TValeur_titre_id = $item->ppal;
                        }
                    }
                }
            }
        }

         return $valeur;
     }


    /**
     * dédoublonne les lib de titre
     *
     * @param array $valeur
     * @return array 
     */
     public static function dedoublonneValueTitle ($valeur, $tomodify) {
        foreach ($tomodify as $item) {
            if (sizeof($item->doubon)) {
                foreach ($item->doubon as $doublon) {
                    foreach ($valeur as $k=>$itemValeur) {
                        if ($itemValeur->TTitre_id == $doublon) {
                            unset($valeur[$k]);
                        }
                    }
                }
            }
        }

         return $valeur;
     }

    /**
     * Reformer le tableau pour faciliter la boucle
     *
     * @param array $valeur
     * @return array 
     */
     public static function equipementAutreForm ($valeur) {
         $vers = $retour = array();
         $ret  = new stdClass();
         if (sizeof($valeur)) {
            foreach ($valeur as $k=>$item) {
                // récupérer les lib des version
                if (!in_array($item->EVersion_Titre, $vers)) {
                    $vers[] = $item->EVersion_Titre;
                }
                $tvaleur[] = $item->EValeur_Valeur;
                if ($valeur[$k+1]->ETitre_Titre != $item->ETitre_Titre) { 
                    $ppl = new stdClass();
                    $ppl->lib  = $item->ETitre_Titre;
                    $ppl->vals = $tvaleur;
                    $tvaleur   = array();

                    $retour[] = $ppl;
                }
            }
         }
         $ret->vers = $vers;
         $ret->rets = $retour;

         return $ret;
     }


    /**
     * Récupération de l'id d'un équipement 
     *
     * @param array $valeur
     * @return array 
     */
     public static function getIdEquip ($txt) {
        $cnx = jDb::getConnection();
        $sql = " SELECT IdEquipements FROM ao_equip WHERE Equip_Ftexte = '" . $txt . "'";
		
        return $cnx->query($sql)->fetch()->IdEquipements;
     }


    /**
     * Récupération des équipement s
     *
     * @param int $id
     * @return array 
     */
     public static function getEquipementAutre ($id) {
        $cnx = jDb::getConnection();
        $sql = " SELECT  EValeur_Valeur, EVersion_Titre, ETitre_Titre
FROM ao_equipValeur
	LEFT JOIN ao_equipVersion ON IdEquipVersion = EValeur_IdVersion
	LEFT JOIN ao_equipTitre ON IdEquipTitre = EValeur_IdTitre
WHERE EVersion_IdEquipements = $id";

        return $cnx->query($sql)->fetchAll();
     }
	 /**
     * Fonction permettant de verifier si une marque donné est dans un essai 
     * @param	int			$_iMarqueId
     * @return	boolean		$bIsMarqueInEssai 
     */
     public static function chekIfIsMarqueInEssai($_iMarqueId) {
		 $oConnexion		= jDb::getConnection();
		 $bIsMarqueInEssai	= false ;
		 $zQuery = "
					SELECT 
						COUNT(ess_id) AS iNombreMarqueEssai 
					FROM    ao_essais
					WHERE   ess_iMarqueId = $_iMarqueId
				   " ;
		 $oResult	= $oConnexion->query($zQuery) ;
		 $oRecord	= $oResult->fetch() ;
		 if ( $oRecord->iNombreMarqueEssai > 0 )
		 {
			$bIsMarqueInEssai = true ;
		 }

		 return $bIsMarqueInEssai ;
     }
	 /**
     * Fonction permettant de verifier si une modele donné est dans un essai 
     * @param		int		$_iMarqueId
     * @param		int		$_iModeleId
     * @return		boolean $bIsModeleInEssai 
     */
     public static function chekIfIsModeleInEssai($_iMarqueId,$_iModeleId)  {
		 $oConnexion		= jDb::getConnection();
		 $bIsModeleInEssai	= false ;
		 $zQuery = "
					SELECT 
						COUNT(ess_id) AS iNombreResult
					FROM    ao_essais
					WHERE   ess_iMarqueId = $_iMarqueId
					AND		ess_iModelId  = $_iModeleId
				   " ;
		 $oResult = $oConnexion->query($zQuery) ;
		 $oRecord	  = $oResult->fetch() ;
		 if ( $oRecord->iNombreResult > 0 )
		 {
			$bIsModeleInEssai = true ;
		 }

		 return $bIsModeleInEssai ;
     }
	 /**
     * Fonction permettant de recuperer les listes des versions
     * @param		int		$_iMarqueId
     * @param		int		$_iModeleId
     * @return		array	$tzListesVersions 
     */
     public static function getVersionByMarqueAndModele($_iMarqueId,$_iModeleId,$_iEssaiId = 0)  {
		 $oConnexion		= jDb::getConnection();
		 $toListesVersions	= array() ;
		 $zQuery = "
					SELECT 
						ess_zVersion
					FROM    ao_essais
					WHERE   ess_iMarqueId = $_iMarqueId
					AND		ess_iModelId  = $_iModeleId
					AND		ess_zVersion  <>''
					AND		ess_zVersion IS NOT NULL
				   " ;
		 if ($_iEssaiId!=0)
		 {
			$zQuery.=" AND ess_id  = $_iEssaiId " ;
		 }
		 $oResult = $oConnexion->query($zQuery) ;
		 while( $oRecord = $oResult->fetch() )
		 {
			array_push ($toListesVersions,$oRecord->ess_zVersion) ;
		 }

		 return $toListesVersions ;
     }
	 /**
     * Fonction permettant de recuperer les listes des versions
     * @param		int		$_iEssaiId
     * @return		array	$tzListesVersions 
     */
     public static function getListesVersionsByEssaiId($_iEssaiId)  {
		 $oConnexion		= jDb::getConnection();
		 $tzListesVersions	= array() ;
		 $zQuery = "
					SELECT 
						ess_zVersion
					FROM    ao_essais
					WHERE   ess_id	= $_iEssaiId

				   " ;
		 $oResult = $oConnexion->query($zQuery) ;
		 while( $oRecord = $oResult->fetch() )
		 {
			 if($oRecord->ess_zVersion) {
				array_push ($tzListesVersions ,$oRecord->ess_zVersion) ;
			 }
		 }

		 return $tzListesVersions ;
     }
	 /**
     * Fonction permettant de recuperer la liste des essais par marque et modele
     * @param		int		$_iMarqueId
     * @param		int		$_iModeleId
     * @return		array	$tiListEssaiId
     */
     public static function getListEssaiIdByMarqueModele($_iMarqueId,$_iModeleId)  {
		 $oConnexion		= jDb::getConnection();
		 $tiListEssaiId		= array() ;
		 $zQuery = "
					SELECT 
						ess_id As iEssaiId
					FROM    ao_essais
					WHERE   ess_iMarqueId	= $_iMarqueId
					AND		ess_iModelId	= $_iModeleId
				   " ;
		 $oResult = $oConnexion->query($zQuery) ;
		 while( $oRecord = $oResult->fetch() )
		 {
			array_push ($tiListEssaiId ,$oRecord->iEssaiId) ;
		 }

		 return $tiListEssaiId ;
     }
	  /**
     * Fonction permettant de recuperer la liste des essais par marque et modele
     * @param		int		$_iEssaiId
     * @param		int		$_iModeleId
     * @return		array	$tiListEssaiId
     */
     public static function getChapitreIdByEssaiModele($_iEssaiId,$_iModeleId)  {
		 $oConnexion		= jDb::getConnection();
		 $zQuery = "
					SELECT 
						chap_id As iChapitreId
					FROM    ao_essais_chapitre
					WHERE   chap_ess_id		= $_iEssaiId
					AND		chap_modele		= $_iModeleId
					LIMIT 1
				   " ;
		 $oResult			= $oConnexion->query($zQuery) ;
		 $oRecord			= $oResult->fetch() ;
		 $iChapitreId		= $oRecord->iChapitreId ;
		
		 return $iChapitreId ;
     }

}